package br.uniceub.fsw.talentos.facade;

import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Locale;
import java.util.StringTokenizer;

/**
 *  Classe utilizada para diversos tipos de conversão
 *  java.sql.Date, java.util.Date, String.
 * @author Sergio Fernando
 * @version 1.0
 * @since Abril/2009
 */
public class Conversor {

    public static String retornarDataAtual() {

        return utilDateToString(new java.util.Date());

    }

    /**
     *  Obtem a hora da JVM em String
     *  no formato "HH:MM:SS"
     *  @return String
     *  @see java.util.Date
     *  @see java.text.SimpleDateFormat
     *  @see java.text.SimpleDateFormat.format
     */
    public static String retornarHoraAtual() {

        return utilTimeToString(new java.util.Date());

    }

    /**
     *  Obtem a data/hora da JVM em String
     *  no formato "dd/MM/yyyy HH:mm:ss"
     *  @return String
     *  @see java.util.Date
     *  @see java.text.SimpleDateFormat
     *  @see java.text.SimpleDateFormat.format
     */
    public static String retornarDataEHoraAtuais() {

        return utilDateTimeToString(new java.util.Date());

    }

    /*---------- Validação de data ----------*/
    /*-- Entrada de data no formato dd/mm/aaaa --*/
    public static boolean validaData(String data) {
        java.util.Date auxData;
        java.sql.Date dataSaida;
        int dia = 0, mes = 0, ano = 0;
        Calendar calendario;
        calendario = Calendar.getInstance();

        try {

            StringTokenizer tokens = new StringTokenizer(data, "/");

            dia = Integer.parseInt(tokens.nextToken());
            mes = Integer.parseInt(tokens.nextToken());
            ano = Integer.parseInt(tokens.nextToken());

            //Critica a validade do dia
            if ((dia < 1) || (dia > 31)) {

                return false;

            }

            //Critica a validade do mês
            if ((mes < 1) || (mes > 12)) {
                return false;
            }

            // Critica se o mês é de 31 dias
            if (((mes == 4) || (mes == 6) || (mes == 9) || (mes == 11)) &&
                    (dia > 30)) {

                return false;

            }

            // Critica mes de fevereiro de ano bissexto
            if (mes == 2) {

                if (dia > 29) {

                    return false;

                }

                if (dia == 29) {

                    if (ano % 4 == 0) {

                        return true;

                    } else {

                        return false;

                    }

                } else {

                    return true;

                }


            }

            calendario.set(ano, (mes - 1), dia, 0, 0, 0);
            calendario.set(Calendar.MILLISECOND, 0);
            auxData = calendario.getTime();

            dataSaida = new java.sql.Date(auxData.getTime());

        } catch (Exception e) {

            return false;

        }

        return true;
    }

    public static boolean ehDataValida(String data) {

        if (data == null || data.length() != 10) {

            return false;

        }

        DateFormat df =
                DateFormat.getDateInstance(DateFormat.SHORT, new Locale("pt",
                "BR"));
        df.setLenient(false);

        try {

            java.util.Date d = df.parse(data);
            return true;

        } catch (ParseException e) {

            return false;

        }
    }

    public static boolean verificarDataDDMMAAAA(String data) {

        if (data == null || data.trim().length() != 8) {

            return false;

        }
        data = data.trim();
        return ehDataValida(data.substring(0, 2) + "/" + data.substring(2, 4) +
                "/" + data.substring(4));
    }

    public static boolean ehDataHoraValida(String sDataHora) {
        if (sDataHora.length() != 19) {
            return false;
        }
        DateFormat df =
                DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM,
                new Locale("pt", "BR"));
        df.setLenient(false);

        try {
            java.util.Date d = df.parse(sDataHora);
            return true;
        } catch (ParseException e) {
            return false;
        }
    }

    /**
     * Verifica se um hor·rio no padr„o 99:99, variando entre 00:00 e 23:59 È v·lido.
     * @param sHorario String - hor·rio formatado a ser validado.
     * @return boolean - true, se o hor·rio for v·lido, false, caso contr·rio.
     */
    public static boolean ehHorarioValido(String sHorario) {
        if (sHorario.length() != 5) {
            return false;
        }
        DateFormat df =
                DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT,
                new Locale("pt", "BR"));
        df.setLenient(false);

        try {
            java.util.Date d = df.parse(Conversor.retornarDataAtual() + " " + sHorario);
            return true;
        } catch (ParseException e) {
            return false;
        }
    }

    public static String stringToAccessDate(String inData) {
        String dia = "";
        String mes = "";
        String ano = "";
        int i;

        // acha a 1a barra e pega o dia
        i = inData.indexOf("/");

        if (i != -1) {
            dia = inData.substring(0, i);
            inData = inData.substring(i + 1);
        }

        // acha a 2a barra e pega o mes e ano
        if (i != -1) {
            mes = inData.substring(0, i);
            ano = inData.substring(i + 1);
        }

        return "#" + mes + "/" + dia + "/" + ano + "#";
    }

    /**
     *  Converte uma data String no formato TO_DATE('01/01/2001','dd/mm/yyyy')
     */
    public static String stringToOracleDate(String inData) {
        String dia = "";
        String mes = "";
        String ano = "";
        int i;

        // acha a 1a barra e pega o dia
        i = inData.indexOf("/");

        if (i != -1) {
            dia = inData.substring(0, i);
            inData = inData.substring(i + 1);
        }

        // acha a 2a barra e pega o mes e ano
        if (i != -1) {
            mes = inData.substring(0, i);
            ano = inData.substring(i + 1);
        }

        return "TO_DATE('" + dia + "/" + mes + "/" + ano + "','dd/mm/yyyy')";
    }

    public static String stringToOracleDate(Date inData) {
        return stringToOracleDate(utilDateToString(inData));
    }

    /**
     * Retorna a data, recebida "quebrada", numa data v·lida no formato String.
     * Se a data n„o for v·lida, retorna null.
     */
    public static String formataData(String dia, String mes, String ano) {
        String data = dia + '/' + mes + '/' + ano;
        return ehDataValida(data) ? data : null;
    }

    /*---------- Conversıes data String para data java.sql.Date ----------*/
    /**
     *  Converte uma data String no formato "dd/MM/yyyy" para o
     *  fromato java.sql.Date
     *  @param inData String
     *  @return java.sql.Date
     *  @see java.sql.Date
     *  @see java.util.Date
     *  @see java.text.SimpleDateFormat
     *  @see java.text.SimpleDateFormat.format
     *  @see java.text.SimpleDateFormat.parse
     *  @see java.text.ParsePosition
     */
    public static java.sql.Date stringToSqlDate(String inData) {
        java.util.Date auxData;
        java.sql.Date outData;
        int dia = 0, mes = 0, ano = 0;
        Calendar calendario;
        calendario = Calendar.getInstance();

        StringTokenizer tokens = new StringTokenizer(inData, "/");
        dia = Integer.parseInt(tokens.nextToken());
        mes = Integer.parseInt(tokens.nextToken());
        ano = Integer.parseInt(tokens.nextToken());

        calendario.set(ano, (mes - 1), dia, 0, 0, 0); // os meses come�?am por 0

        calendario.set(Calendar.MILLISECOND, 0);
        auxData = calendario.getTime();

        outData = new java.sql.Date(auxData.getTime());
        return outData;
    }

    public static java.sql.Timestamp stringToTimestamp(String inData) {
        java.util.Date auxData;
        auxData = stringToUtilDate(inData);
        return new java.sql.Timestamp(auxData.getTime());
    }

    /*---------- Conversıes data java.sql.Date para data String ----------*/
    /**
     *  Converte uma data sql.Date para String no formato "DD/MM/AAAA"
     *  @param inData java.sql.Date
     *  @return String
     *  @see java.sql.Date
     *  @see java.text.SimpleDateFormat
     *  @see java.text.SimpleDateFormat.format
     */
    public static String sqlDateToString(java.sql.Date inData) {
        SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
        formatador.setLenient(false);
        return formatador.format(inData);
    }

    /**
     *  Converte uma data sql.Date para String no formato "AAAAMMDD"
     *  @param inData java.sql.Date
     *  @return String
     *  @see java.sql.Date
     *  @see java.text.SimpleDateFormat
     *  @see java.text.SimpleDateFormat.format
     */
    public static String sqlDateToStringAAAAMMDD(java.sql.Date inData) {
        SimpleDateFormat formatador = new SimpleDateFormat("yyyyMMdd");
        formatador.setLenient(false);
        return formatador.format(inData);
    }

    public static String TimestampToString(java.sql.Timestamp inData) {
        SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
        formatador.setLenient(false);
        return formatador.format(inData);
    }

    public static String TimestampToString(java.sql.Timestamp inData,
            String formato) {
        SimpleDateFormat formatador = new SimpleDateFormat(formato);
        formatador.setLenient(false);
        return formatador.format(inData);
    }

    /**
     *  Converte uma data sql.Date para String no formato "ddMMyyyy"
     *  @param inData java.sql.Date
     *  @return String
     *  @see java.sql.Date
     *  @see java.text.SimpleDateFormat
     *  @see java.text.SimpleDateFormat.format
     */
    public static String sqlDateToStringSemDelimitadores(java.sql.Date inData) {
        SimpleDateFormat formatador = new SimpleDateFormat("ddMMyyyy");
        return formatador.format(inData);
    }

    /*---------- Conversıes data java.util.Date para data java.sql.Date ----------*/
    public static java.sql.Timestamp utilDateToTimestamp(java.util.Date inData) {
        return new java.sql.Timestamp(inData.getTime());
    }

    public static java.sql.Date utilDateToSqlDate(java.util.Date inData) {
        return stringToSqlDate(utilDateToString(inData));
    }

    /*---------- Conversıes data java.sql.Date para data java.util.Date ----------*/
    public static java.util.Date sqlDateToUtilDate(java.sql.Date inData) {
        return stringToUtilDate(sqlDateToString(inData));
    }

    /*---------- Conversıes data String para data java.util.Date ----------*/
    /**
     *  Converte uma data String no formato "DDMMAAAAHHMMSS" para java.util.Date
     *  @param inDataHora String
     *  @return java.util.Date
     */
    public static java.util.Date StringDDMMAAAAHHMMSSToDate(String inDataHora) {
        SimpleDateFormat sdf = new SimpleDateFormat("ddMMyyyyHHmmss");
        ParsePosition p = new ParsePosition(0);
        return sdf.parse(inDataHora, p);
    }

    /**
     *  Converte uma data String no formato "AAAAMMDDHHMMSS" para java.util.Date
     *  @param inDataHora String
     *  @return java.util.Date
     */
    public static java.util.Date StringAAAAMMDDHHMMSSToDate(String inDataHora) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
        ParsePosition p = new ParsePosition(0);
        return sdf.parse(inDataHora, p);
    }

    /**
     *  Converte uma data String no formato "DD/MM/AAAA HH:MM:SS" para java.util.Date
     *  @param inDataHora String
     *  @return java.util.Date
     */
    public static java.util.Date StringToDateTime(String inDataHora) {
        SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
        ParsePosition p = new ParsePosition(0);
        return sdf.parse(inDataHora, p);
    }

    /**
     *  Converte uma data String no formato "AAAAMMDD" para java.util.Date
     *  @param inData String
     *  @return java.util.Date
     */
    public static java.util.Date StringAAAAMMDDToDate(String inData) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
        ParsePosition p = new ParsePosition(0);
        return sdf.parse(inData, p);
    }

    /**
     *  Converte uma data String no formato "DDMMAAAA" para java.util.Date
     *  @author PauloCSC - 02/03/2004
     * 
     *  @param inData String
     *  @return java.util.Date
     */

    /**
     *  Converte uma data String no formato "dd/MM/yyyy" para o formato java.util.Date
     *  @param inData String
     *  @return java.util.Date
     *  @see java.util.Date
     *  @see java.text.SimpleDateFormat
     *  @see java.text.SimpleDateFormat.parse
     *  @see java.text.ParsePosition
     */
    public static java.util.Date stringToUtilDate(String inData) {
        java.util.Date auxData;
        int dia = 0, mes = 0, ano = 0;

        Calendar calendario;
        calendario = Calendar.getInstance();

        StringTokenizer tokens = new StringTokenizer(inData, "/");
        dia = Integer.parseInt(tokens.nextToken());
        mes = Integer.parseInt(tokens.nextToken());
        ano = Integer.parseInt(tokens.nextToken());

        calendario.set(ano, (mes - 1), dia, 0, 0, 0); // os meses come�?am por 0

        calendario.set(Calendar.MILLISECOND, 0);
        auxData = calendario.getTime();

        return auxData;
    }

    /*---------- Conversıes data java.util.Date para data String ----------*/
    /**
     *  Converte uma data java.util.Date para String no formato "DDMMAAAAHHMMSS"
     *  @param inData java.util.Date
     *  @return String
     *  @see java.util.Date
     */
    public static String utilDateToStringDDMMAAAAHHMMSS(java.util.Date inData) {
        SimpleDateFormat formatador = new SimpleDateFormat("ddMMyyyyHHmmss");
        return formatador.format(inData);
    }

    /**
     *  Converte uma data no formato java.util.Date para String no formato "dia de m�?s de ano"
     *  Ex: "25 de janeiro de 2002"
     *  @param inData java.util.Date
     *  @return String
     *  @see java.util.Date
     */
    public static String utilDateToStringPorExtenso(java.util.Date inData) {
        String mes = "";
        String descricao = "";
        descricao = inData.getDate() + " de ";

        int intMes = inData.getMonth() + 1;
        switch (intMes) {
            case 1:
                mes = "janeiro";
                break;
            case 2:
                mes = "fevereiro";
                break;
            case 3:
                mes = "marco";
                break;
            case 4:
                mes = "abril";
                break;
            case 5:
                mes = "maio";
                break;
            case 6:
                mes = "junho";
                break;
            case 7:
                mes = "julho";
                break;
            case 8:
                mes = "agosto";
                break;
            case 9:
                mes = "setembro";
                break;
            case 10:
                mes = "outubro";
                break;
            case 11:
                mes = "novembro";
                break;
            case 12:
                mes = "dezembro";
                break;
        }

        descricao = descricao + mes + " de " + (inData.getYear() + 1900);
        return descricao;
    }

    /**
     *  Converte uma data java.util.Date para String no formato "dd/MM/yyyy"
     *  @param inData java.util.Date
     *  @return String
     *  @see java.util.Date
     *  @see java.text.SimpleDateFormat
     *  @see java.text.SimpleDateFormat.format
     */
    public static String utilDateToString(java.util.Date inData) {
        SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy");
        return formatador.format(inData);
    }

    /**
     * Converte uma data java.util.Date para String no formato "dd/MM/yyyy", se n„o for nula.
     * Se for nula, return null.
     * @param inData
     * @return
     */
    public static String utilDateToStringNull(java.util.Date inData) {
        return inData == null ? null : utilDateToString(inData);
    }

    /**
     * Converte util.date para ddmmaaa
     * 
     * @param inData
     * @return
     */
    public static String utilDateToDDMMAAAA(java.util.Date inData) {
        SimpleDateFormat formatador = new SimpleDateFormat("ddMMyyyy");
        return formatador.format(inData);
    }

    /**
     *  Converte uma data java.util.Date para String no formato "AAAAMMDD"
     *  @param inData java.util.Date
     *  @return String
     *  @see java.util.Date
     *  @see java.text.SimpleDateFormat
     *  @see java.text.SimpleDateFormat.format
     */
    public static String utilDateToStringAAAAMMDD(java.util.Date inData) {
        SimpleDateFormat formatador = new SimpleDateFormat("yyyyMMdd");
        return formatador.format(inData);
    }

    /**
     *  Converte uma data java.util.Date para String no formato "HH:mm:ss"
     *  @param inData java.util.Date
     *  @return String
     *  @see java.util.Date
     *  @see java.text.SimpleDateFormat
     *  @see java.text.SimpleDateFormat.format
     */
    public static String utilTimeToString(java.util.Date inData) {
        SimpleDateFormat formatador = new SimpleDateFormat("HH:mm:ss");
        return formatador.format(inData);
    }

    /**
     *  Converte uma data java.util.Date para String no formato "HH:mm:ss:SS"
     *  @param inData java.util.Date
     *  @return String
     *  @see java.util.Date
     *  @see java.text.SimpleDateFormat
     *  @see java.text.SimpleDateFormat.format
     */
    public static String utilTimeToStringComMilisegundo(java.util.Date inData) {
        SimpleDateFormat formatador = new SimpleDateFormat("HH:mm:ss:SS");
        return formatador.format(inData);
    }

    public static String utilTimeToStringSemSegundos(java.util.Date inData) {
        SimpleDateFormat formatador = new SimpleDateFormat("HH:mm");
        return formatador.format(inData);
    }

    /**
     *  Converte uma data java.util.Date para String no formato "dd/MM/yyyy HH:mm:ss"
     *  @param inData java.util.Date
     *  @return String
     *  @see java.util.Date
     *  @see java.text.SimpleDateFormat
     *  @see java.text.SimpleDateFormat.format
     */
    public static String utilDateTimeToString(java.util.Date inData) {
        SimpleDateFormat formatador =
                new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
        return formatador.format(inData);
    }

    public static String utilDateTimeToStringSemSegundos(java.util.Date inData) {
        SimpleDateFormat formatador = new SimpleDateFormat("dd/MM/yyyy HH:mm");
        return formatador.format(inData);
    }

    public static String utilTimeToStringComMilisegundos(java.util.Date inData) {
        SimpleDateFormat formatador = new SimpleDateFormat("HH:mm:ss:SS");
        return formatador.format(inData);
    }

    public static String doubleToString(double valor,
            int casasDecimais) {
        String outData;
        DecimalFormat formatador =
                new DecimalFormat("#,###,###,###,##0." + "0000000000000000000".substring(0,
                casasDecimais));
        outData = formatador.format(valor);
        return outData;
    }

    public static double stringToDouble(String valor) {
        StringBuffer str = new StringBuffer(valor);

        // descobre o caracter separador das casas decimais
        int i;
        for (i = (str.length() - 1);
                (i >= 0) && ("0123456789".indexOf(str.charAt(i)) >= 0); i--);

        if (i >= 0) {
            // for�?a o caracter das casas decimais ser o ponto (.)
            str.setCharAt(i, '.');

            // busca outros caracteres separadores, retirando-os do valor
            for (int j = 0; j < i;) {
                // se encontrou, elimina
                if (".,".indexOf(str.charAt(j)) >= 0) {
                    str.deleteCharAt(j);
                    i--;
                } else {
                    j++;
                }
            }
        }

        return Double.parseDouble(str.toString());
    }

    public static String doubleToString(double valor2) {
        String stringValor2 = (new Double(valor2)).toString(valor2);
        stringValor2 = stringValor2.replace('.', ',');
        return stringValor2;
    }

    public static String doubleExponencialToString(double inEntrada) {
        DecimalFormat formatador =
                new DecimalFormat("###########################");
        return formatador.format(inEntrada);
    }

    public static String doubleExponencialDecimalToString(double inEntrada) {
        DecimalFormat formatador =
                new DecimalFormat("###########################.00");
        return formatador.format(inEntrada);
    }

    /**
     *  Converte uma string em um int
     *  @param inEntrada String
     *  @return int
     */
    public static int stringToInt(String inEntrada) {
        return Integer.parseInt(inEntrada);
    }

    public static long stringToLong(String inEntrada) {
        return Long.parseLong(inEntrada);
    }

    public static String currencyToString(double inEntrada) {
        String outData;
        DecimalFormat formatador = new DecimalFormat("###########0.00");
        outData = formatador.format(inEntrada);
        outData = outData.replace('.', ',');
        return outData;
    }

    public static String valorMonetarioToString(double inEntrada) {
        String outData;
        DecimalFormat formatador =
                new DecimalFormat("##,###,###,###,###,##0.00");
        outData = formatador.format(inEntrada);
        outData = outData.replace('.', '/');
        outData = outData.replace(',', '.');
        outData = outData.replace('/', ',');
        return outData;
    }

    public static String numberToString(double inEntrada) {
        String outData;
        DecimalFormat formatador = new DecimalFormat("#,###,###,###,###,###");
        outData = formatador.format(inEntrada);
        outData = outData.replace(',', '.');
        return outData;
    }

    public static String floatToString(float valor2) {
        String stringValor2 = (new Float(valor2)).toString(valor2);
        stringValor2 = stringValor2.replace('.', ',');
        return stringValor2;
    }

    public static float stringToFloat(String inEntrada) {
        inEntrada = inEntrada.replace(',', '.');
        float floatValor = Float.parseFloat(inEntrada);
        return floatValor;
    }

    public static String ehNulo(String inEntrada) {
        return (inEntrada == null) ? "" : inEntrada;
    }

    public static boolean seNulo(String inEntrada) {
        return (inEntrada == null) || (inEntrada.trim().length() == 0);
    }

    public static boolean stringToBoolean(String entrada) {
        return entrada.equalsIgnoreCase("true");
    }

    public static java.util.Date TimestampToUtilDate(Timestamp dataHora) {
        return new java.util.Date(dataHora.getTime());

    //Conversor.stringToUtilDate(Conversor.TimestampToString(dataHora));
    }

    public static boolean comparaDatas(String data1, String data2) {
        if (!ehDataValida(data1) || !ehDataValida(data2)) {
            return false;
        }
        java.util.Date dataInic = stringToUtilDate(data1);
        java.util.Date dataTerm = stringToUtilDate(data2);

        return dataInic.after(dataTerm);
    }

    public static String vazioSeNull(Object valor) {
        return (valor == null) ? "" : valor.toString();
    }

    public static String nullSeVazio(String valor) {
        return ((valor == null) || (valor.trim().equals(""))) ? null : valor;
    }

    public static String retornaZeroSeHoraNula(Object valor) {
        return (valor == null) ? "00:00:00" : valor.toString();
    }

    /**
     * Recebe uma data com horas "aaaa-mm-dd hh:mm:ss" e retorna apenas a data
     * @param string
     * Utilidade maior: MySQL (nao usar a conversao do BaseDAO)
     */
    public static String formataData(String string) {
        if (string == null) {
            return null;
        } else {
            String data =
                    string.substring(8, 10) + "/" + string.substring(5, 7) + "/" +
                    string.substring(0, 4);
            return validaData(data) ? data : null;
        }
    }

    public static String letrasIniciaisEmMaiusculo(String texto) {

        String result = "";
        String nome = new String();

        StringTokenizer token = new StringTokenizer(texto.toLowerCase(), " ");

        while (token.hasMoreElements()) {
            nome = token.nextToken();

            if (!nome.equals("da")) {
                result =
                        result + nome.substring(0, 1).toUpperCase() + nome.substring(1) +
                        " ";
            } else {
                result = result + nome + " ";
            }
        }

        return result;
    }

    public static String tratarCaracteresEspeciais(String str) {

        if (str.indexOf("/u0025") != -1) {
            str = str.replaceAll("/u0025", "%");
        }
        if (str.indexOf("/u0026") != -1) {
            str = str.replaceAll("/u0026", "&");
        }
        return str;
    }

    /**
     * Formata o valor Double recebido em String no formato 999.999.999,99.
     * 
     * @param valor a ser formatado
     *            
     * @return Uma String contendo o valor formatado.
     */
    public static String formataValorParaString(Double valor) {

        String strValor = valor.toString();
        strValor = strValor.replace('.', ',');
        String[] temp = strValor.split(",");
        StringBuffer sb = new StringBuffer(temp[0]);

        if (temp.length > 0 && temp[0].length() > 3) {

            int pos = temp[0].length() - 3;
            for (int i = temp[0].length() - 1; i >= 0; i--) {

                if (i > 0 && i == pos) {

                    sb.insert(i, ".");
                    pos -= 3;

                }
            }
        }

        if (temp[1] != null && temp[1].length() == 1) {

            temp[1] = temp[1].concat("0");

        }

        strValor = sb.toString() + "," + temp[1];

        return strValor;

    }

    public static String formataValorMonetarioParaString(Double valor) {

        NumberFormat formataValorMonetario = NumberFormat.getCurrencyInstance();
        String strValor = formataValorMonetario.format(valor);
        if (strValor == null || strValor.trim().length() == 0) {
            return "";
        }
        int posDolar = strValor.indexOf('$');
        if (posDolar >= 0) {
            strValor = strValor.substring(++posDolar).trim();
        }
        strValor = strValor.replace('.', ',');
        String[] temp = strValor.split(",");
        StringBuffer buffValor = new StringBuffer();

        for (int i = 0; i < temp.length - 1; i++) {
            buffValor.append(temp[i]).append(".");
        }
        strValor = buffValor.toString();
        if (strValor.endsWith(".")) {
            strValor = strValor.substring(0, strValor.length() - 1); // suprime o ˙ltimo ponto (".")

        }
        strValor += "," + temp[temp.length - 1];

        return strValor;
    }

/*    public static String normalizaStringConsultaDesconsiderandoAcentuacao(String string) {

        string = string.toUpperCase();
        string = string.replace('A', '_');
        string = string.replace('E', '_');
        string = string.replace('I', '_');
        string = string.replace('O', '_');
        string = string.replace('U', '_');

        string = string.replace('¬', '_');
        string = string.replace(' ', '_');
        string = string.replace('Œ', '_');
        string = string.replace('‘', '_');
        string = string.replace('€', '_');

        string = string.replace('¡', '_');
        string = string.replace('…', '_');
        string = string.replace('Õ', '_');
        string = string.replace('�?', '_');
        string = string.replace('�?�', '_');

        string = string.replace('√', '_');
        string = string.replace('’', '_');

        string = string.replace('ƒ', '_');
        string = string.replace('À', '_');
        string = string.replace('‹', '_');
        string = string.replace('÷', '_');
        string = string.replace('œ', '_');

        string = string.replace('¿', '_');
        string = string.replace('»', '_');
        string = string.replace('Ã', '_');
        string = string.replace('“', '_');
        string = string.replace('Ÿ', '_');
        string = string.replace(' ', '%');

        string = string.replace('C', '_');
        string = string.replace('«', '_');

        return string;

    }   */

    public static String realizarSomaDiasDataAtual(int qtdDias, int qtdMeses,
            int qtdAnos) {
        Date data = new Date();
        GregorianCalendar calendario =
                new GregorianCalendar(data.getYear() + 1900, data.getMonth(),
                data.getDate());
        calendario.add(GregorianCalendar.DAY_OF_MONTH, qtdDias);
        calendario.add(GregorianCalendar.MONTH, qtdMeses);
        calendario.add(GregorianCalendar.YEAR, qtdAnos);
        return Conversor.utilDateToString(calendario.getTime());
    }

    public static String recuperaDataDeHoje() {
        
        Date data = new Date();
        return Conversor.utilDateToString(data);
    
    }

    /**
     *  Soma uma determinada quantidade de dias ˙teis a data Atual.
     *  
     *  Uso da fun�?„o do banco RETORNA_DATA_PRAZO_DIAS_UTEIS(p_data_inicio IN DATE, p_qtd_dias_uteis IN NUMBER, p_cod_unidade IN NUMBER)
     *  Que chama a procedure QTDDIASUTEIS(iDataInicio varchar2, iDataTermino varchar2, iCodLotacao Number, oDias out Number) 
     *  que calcula quantos dias ˙teis possui no intervalo de datas de uma localidade analisando se os dias est„o presentes na tabela
     *  hist_dias_sem_expediente, que informa os dias sem expediente de uma determinada lota�?„o.
     *  
     *  @param dtAtual data a qual que ser· adicionada os dias ˙teis.
     *  @param qtdDias quantidade de dias ˙teis que ser„o adicionados a dtAtual.
     *  @param unidadeGestora cÛdigo da unidade gestora na qual est· ambientada, 
     *  informa�?„o esta, necess·ria para o conhecimento de feriados locais. 
     *  
     *  @return String que representa a data modificada.
     */
    
    
}
